home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.3d26 source / tn3270 / serscrn.c < prev    next >
Text File  |  1991-02-15  |  13KB  |  563 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.3d21, January 17, 1991
  5.  *  Copyright (c) 1988, 1989, 1990, 1991 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #define __SEG__ 3270seg3
  34. #include "maclib.h"
  35. #include "termdef.h"
  36. #include "globals.h"
  37.  
  38. extern Rect textRect, gr_rect;
  39. extern short maxoff, maxcnt;
  40. extern PaletteHandle myPalette;
  41. extern RGBColor realwhite;
  42. extern short scrhsize, scrhoff;
  43. extern char servermode, serverflags;
  44. extern unsigned char tcphostname[];        /* cshostname, or prompt response */
  45.  
  46. char skiplf, escmode;
  47.  
  48. short msgoffset;
  49. unsigned char *linetext;
  50. unsigned short *lineattr;
  51. short linelen;
  52. unsigned char *proctext;
  53. unsigned short *procattr;
  54. unsigned char *prochost;
  55. char respflag;
  56.  
  57. unsigned char cptoebc[] = {
  58.     0x00,0x01,0x02,0x03,0x37,0x2d,0x2e,0x2f,
  59.     0x16,0x05,0x25,0x0b,0x0c,0x0d,0x0e,0x0f,
  60.     0x10,0x11,0x12,0x3b,0x3c,0x3d,0x32,0x26,
  61.     0x18,0x19,0x3f,0x27,0x1c,0x1d,0x1e,0x1f,
  62.     0x40,0x5a,0x7f,0x7b,0x5b,0x6c,0x50,0x7d,
  63.     0x4d,0x5d,0x5c,0x4e,0x6b,0x60,0x4b,0x61,
  64.     0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,
  65.     0xf8,0xf9,0x7a,0x5e,0x4c,0x7e,0x6e,0x6f,
  66.     0x7c,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
  67.     0xc8,0xc9,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,
  68.     0xd7,0xd8,0xd9,0xe2,0xe3,0xe4,0xe5,0xe6,
  69.     0xe7,0xe8,0xe9,0xad,0xe0,0xbd,0x5f,0x6d,
  70.     0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  71.     0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
  72.     0x97,0x98,0x99,0xa2,0xa3,0xa4,0xa5,0xa6,
  73.     0xa7,0xa8,0xa9,0xc0,0x4f,0xd0,0xa1,0x07};
  74.  
  75. putscr(s, slen, wr)
  76. unsigned char *s;
  77. short slen;
  78. char wr;
  79. {
  80. static unsigned char idstr[] = {0x1b, 0x2f, 0x5a};
  81. register unsigned char a, c;
  82. register short count;
  83. short i, m, newadr;
  84. char writeflg;
  85. unsigned char saverow;
  86.  
  87. if (slen == 0) return;
  88. writeflg = 0;
  89. newadr = curadr;
  90. for (count=0; count < slen; count++) {
  91.     a = s[count];
  92.     if (wr) mout(a);
  93.     c = cptoebc[a & 0x7f];
  94.     switch(escmode) {
  95.         case 0:                /* no preceding ESC */
  96.             if (c >= 0x40) skiplf = 0;
  97.             switch(c) {
  98.                 case 0x2f:                /* bell (07) */
  99.                     pndbeep = 1;
  100.                     break;
  101.                 case 0x16:                /* backspace (08) */
  102.                     if (newadr == 0) newadr = maxoff;
  103.                     else newadr--;
  104.                     break;
  105.                 case 0x05:                /* horizontal tab (09) */
  106.                     newadr >> 2;
  107.                     newadr += 1;
  108.                     newadr << 2;
  109.                     if (newadr > maxoff) newadr = 0;
  110.                     break;
  111.                 case 0x25:                /* line feed (0A) */
  112.                     if (skiplf) {
  113.                         skiplf = 0;
  114.                         break;
  115.                         }
  116.                     newadr = (newadr/scrhsize) * scrhsize;
  117.                     m = maxoff/scrhsize;
  118.                     i = newadr/scrhsize;
  119.                     if (i < m) newadr += scrhsize;
  120.                     else {
  121.                         scrollscrn();
  122.                         writeflg = 0;
  123.                         }
  124.                     break;
  125.                 case 0x0b:                /* vertical tab (0B) */
  126.                     newadr += scrhsize;
  127.                     if (newadr > maxoff) newadr -= maxcnt;
  128.                     break;
  129.                 case 0x0c:                /* form feed (0C) */
  130.                     clrscn();
  131.                     invldscr();
  132.                     newadr = 0;
  133.                     break;
  134.                 case 0x0d:                /* carriage return (0D) */
  135.                     newadr = (newadr/scrhsize) * scrhsize;
  136.                     break;
  137.                 case 0x27:                /* ESC */
  138.                     escmode = 1;
  139.                 default:
  140.                     if (c < 0x40) break;    /* ignore other control chars. */
  141.                                         /* data character */
  142.                     if ((c == 0xad) || (c == 0xbd)) newchar(newadr, c, 0x4000, 0);
  143.                     else newchar(newadr, c, 0, 0);
  144.                     writeflg = 1;
  145.                     newadr++;
  146.                     if ((newadr%scrhsize) == 0) skiplf = 1;
  147.                     if (newadr == maxcnt) {
  148.                         newadr = (maxoff/scrhsize) * scrhsize;
  149.                         scrollscrn();
  150.                         writeflg = 0;
  151.                         }
  152.                     break;
  153.                 }
  154.             break;
  155.         case 1:            /* first char. after ESC */
  156.             switch(c) {
  157.                 case 0xc1:        /* A - up */
  158.                     if ((newadr-scrhsize) >= 0) newadr -= scrhsize;
  159.                     escmode = 0;
  160.                     break;
  161.                 case 0xc2:        /* B - down */
  162.                     if ((newadr+scrhsize) < maxcnt) newadr += scrhsize;
  163.                     escmode = 0;
  164.                     break;
  165.                 case 0xc3:        /* C - right */
  166.                     if ((newadr+1) < maxcnt) newadr++;
  167.                     escmode = 0;
  168.                     break;
  169.                 case 0xc4:        /* D - left */
  170.                     if ((newadr-1) >= 0) newadr--;
  171.                     escmode = 0;
  172.                     break;
  173.                 case 0xc8:        /* H - cursor home */
  174.                     newadr = 0;
  175.                     escmode = 0;
  176.                     break;
  177.                 case 0xc9:        /* I - reverse line feed */
  178.                     if (newadr > scrhoff) newadr -= scrhsize;
  179.                     else {
  180.                         revscroll();
  181.                         writeflg = 0;
  182.                         }
  183.                     escmode = 0;
  184.                     break;
  185.                 case 0xd1:        /* J - erase to end of screen */
  186.                     i = newadr;
  187.                     newchar(i, 0, 0, 0);
  188.                     i++;
  189.                     while (i < maxcnt) {
  190.                         newchar(i, 0, 0, 0);
  191.                         i++;
  192.                         }
  193.                     writeflg = 1;
  194.                     escmode = 0;
  195.                     break;
  196.                 case 0xd2:        /* K - erase to end of line */
  197.                     i = newadr;
  198.                     newchar(i, 0, 0, 0);
  199.                     i++;
  200.                     while ((i < maxcnt) && ((i%scrhsize) != 0)) {
  201.                         newchar(i, 0, 0, 0);
  202.                         i++;
  203.                         }
  204.                     writeflg = 1;
  205.                     escmode = 0;
  206.                     break;
  207.                 case 0xe8:        /* Y - start of cursor address */
  208.                     escmode = 2;
  209.                     break;
  210.                 case 0xe9:        /* Z - return my terminal type */
  211.                     if (tcpflg) {
  212.                         tcpwrite(idstr, 3);
  213.                         }
  214.                     else if (serflg) {
  215.                         mout(idstr[0]);
  216.                         mout(idstr[1]);
  217.                         mout(idstr[2]);
  218.                         }
  219.                     escmode = 0;
  220.                     break;
  221.                 default:
  222.                     escmode = 0;
  223.                     break;
  224.                 }
  225.             break;
  226.         case 2:            /* second char. after ESC */
  227.             saverow = a;
  228.             escmode = 3;
  229.             break;
  230.         case 3:            /* third char. after ESC */
  231.             newadr = (saverow - 0x20) * scrhsize + a - 0x20;
  232.             if (newadr < 0) newadr = 0;
  233.             if (newadr > maxoff) newadr = maxoff;
  234.             escmode = 0;
  235.             break;
  236.         default:
  237.             break;
  238.         }
  239.     }
  240. if (writeflg) newwrite(0);
  241. if (curadr != newadr) {
  242.     curadr = newadr;
  243.     newcur();
  244.     }
  245. }
  246.  
  247. scrollscrn()
  248. {
  249. register short i, n;
  250. unsigned char * cptr;
  251. short * iptr;
  252.  
  253. /* update character and attribute buffers */
  254. n = maxcnt/scrhsize - 1;
  255. cptr = chrbuff;
  256. iptr = atrbuff;
  257. for (i=0; i < n; i++) {
  258.     movmem(cptr+scrhsize, cptr, scrhsize);
  259.     movmem(iptr+scrhsize, iptr, scrhsize<<1);
  260.     cptr += scrhsize;
  261.     iptr += scrhsize;
  262.     }
  263. setmem(cptr, scrhsize, 0);
  264. setmem(iptr, scrhsize<1, 0);
  265.  
  266. /* prevent drawing of saved input */
  267. in_len = 0;
  268. inrect.top = inrect.left = 32767;
  269. inrect.bottom = inrect.right = -32767;
  270.  
  271. /* update bitmap or screen */
  272. invldscr();
  273. }
  274.  
  275. revscroll()
  276. {
  277. register short i, n;
  278. unsigned char * cptr;
  279. short * iptr;
  280.  
  281. /* update character and attribute buffers */
  282. n = maxcnt/scrhsize - 1;
  283. cptr = chrbuff + maxcnt - scrhsize;
  284. iptr = atrbuff + maxcnt - scrhsize;
  285. for (i=0; i < n; i++) {
  286.     movmem(cptr-scrhsize, cptr, scrhsize);
  287.     movmem(iptr-scrhsize, iptr, scrhsize<<1);
  288.     cptr -= scrhsize;
  289.     iptr -= scrhsize;
  290.     }
  291. setmem(cptr, scrhsize, 0);
  292. setmem(iptr, scrhsize<1, 0);
  293.  
  294. /* prevent drawing of saved input */
  295. in_len = 0;
  296. inrect.top = inrect.left = 32767;
  297. inrect.bottom = inrect.right = -32767;
  298.  
  299. /* update bitmap or screen */
  300. invldscr();
  301. }
  302.  
  303. putsrv(s, slen, inp)
  304. unsigned char *s;
  305. short slen;
  306. char inp;
  307. {
  308. register unsigned char a, c;
  309. short count, i, len, m, newadr, startadr;
  310. char writeflg;
  311. unsigned char *cptr;
  312.  
  313. if (slen == 0) return;
  314. writeflg = 0;
  315. newadr = curadr;
  316. startadr = maxcnt - scrhsize * 2;
  317. for (count=0; count < slen; count++) {
  318.     a = s[count];
  319.     c = cptoebc[a & 0x7f];
  320.     if (!inp) {
  321.         srvnewchar(c);
  322.         continue;
  323.         }
  324.     switch(c) {
  325.         case 0x16:                /* backspace (08) */
  326.             if (newadr == startadr) break;
  327.             newadr--;
  328.             newchar(newadr, 0, 0, 0);
  329.             writeflg = 1;
  330.             break;
  331.         case 0x0d:                /* carriage return (0D) */
  332.             cptr = chrbuff + maxoff;
  333.             for (i = scrhsize*2; i > 0; i--) {
  334.                 a = *(cptr--);
  335.                 if ((a != 0) && (a != 0x40)) break;
  336.                 }
  337.             len = i;
  338.             newadr = startadr;
  339.             if (len == 0) break;
  340.             if (serflg) {
  341.                 respflag = 1;
  342.                 cptr = chrbuff + startadr;
  343.                 for (i = 0; i < len; i++) {
  344.                     mout(((*xtabh)[cptr[i]]) & 0x7f);
  345.                     }
  346.                 mout(0x0d);
  347.                 }
  348.             else {
  349.                 srvtext(chrbuff + startadr, atrbuff + startadr, len);
  350.                 cptr = chrbuff + startadr;
  351.                 for (i = 0; i < len; i++) {
  352.                     cptr[i] = (*xtabh)[cptr[i]];
  353.                     }
  354.                 cptr[len++] = 0x0d;
  355.                 cptr[len++] = 0x0a;
  356.                 tcpwrite(cptr, len);
  357.                 }
  358.             setmem(chrbuff + startadr, scrhsize*2, 0);
  359.             setmem(atrbuff + startadr, scrhsize*4, 0);
  360.  
  361.             /* prevent drawing of saved input */
  362.             in_len = 0;
  363.             inrect.top = inrect.left = 32767;
  364.             inrect.bottom = inrect.right = -32767;
  365.  
  366.             /* update bitmap or screen */
  367.             invldscr();
  368.             break;
  369.         default:
  370.             if (c < 0x40) break;    /* ignore other control chars. */
  371.                                 /* data character */
  372.             if (newadr == maxoff) {
  373.                 beep();
  374.                 break;
  375.                 }
  376.             if ((c == 0xad) || (c == 0xbd)) newchar(newadr, c, 0x4006, 6);
  377.             else newchar(newadr, c, 6, 6);
  378.             writeflg = 1;
  379.             newadr++;
  380.             break;
  381.         }
  382.     }
  383. if (writeflg) newwrite(0);
  384. if (curadr != newadr) {
  385.     curadr = newadr;
  386.     newcur();
  387.     }
  388. }
  389.  
  390. srvnewchar(c)
  391. unsigned char c;
  392. {
  393. int rc;
  394.  
  395. switch(c) {
  396.     case 0x25:
  397.                 rc = srvproc(linetext, lineattr, linelen);
  398.                 if (rc == 0) srvtext(linetext, lineattr, linelen);
  399.                 linelen = 0;                
  400.                 break;
  401.     default:
  402.                 if (c < 0x40) break;
  403.                 if (linelen == 512) break;
  404.                 linetext[linelen] = c;
  405.                 if ((c == 0xad) || (c == 0xbd)) lineattr[linelen++] = 0x4000;
  406.                 else lineattr[linelen++] = 0;
  407.                 break;
  408.     }
  409. }
  410.  
  411. srvtext(text, attr, len)
  412. unsigned char *text;
  413. unsigned short *attr;
  414. short len;
  415. {
  416. short i, linecount, scrollcount;
  417.  
  418. if (len == 0) return;
  419. linecount = (len + scrhsize - 1)/scrhsize;
  420. scrollcount = linecount - (maxcnt - scrhsize*2 - msgoffset)/scrhsize;
  421. if (scrollcount > 0) {
  422.     for (i = 0; i < scrollcount; i++) {
  423.         srvscroll();
  424.         msgoffset -= scrhsize;
  425.         }
  426.     }
  427. if (((attr[0] & 0x07) == 6) || respflag) {
  428.     for (i = 0; i < len; i++) {
  429.         attr[i] &= 0xFFF8;
  430.         attr[i] |= 5;
  431.         }
  432.     respflag = 0;
  433.     }
  434. movmem(text, chrbuff+msgoffset, len);
  435. movmem(attr, atrbuff+msgoffset, len<<1);
  436. msgoffset += linecount*scrhsize;
  437.  
  438. /* prevent drawing of saved input */
  439. in_len = 0;
  440. inrect.top = inrect.left = 32767;
  441. inrect.bottom = inrect.right = -32767;
  442.  
  443. /* update bitmap or screen */
  444. invldscr();
  445. }
  446.  
  447. int srvproc(text, attr, len)
  448. unsigned char *text;
  449. unsigned short *attr;
  450. short len;
  451. {
  452. short i;
  453. static char hostok = 0;
  454. unsigned char *irchost;
  455. short ircsize;
  456.  
  457. if (len == 0) return(0);
  458. if (serverflags == 0) return(0);
  459.  
  460. movmem(text, proctext, len);
  461. movmem(attr, procattr, len<<1);
  462.  
  463. /* IRC processing */
  464. if (len < 5) return(0);
  465. for (i = 0; i < 5; i++) {
  466.     proctext[i] = (*xtabh)[proctext[i]];
  467.     }
  468. proctext[5] = 0;
  469. if (strcmp(proctext, "PING ") == 0) {
  470.     if (hostok == 0) {
  471.         hostok = 1;
  472.         strcpy(prochost, "PONG ");
  473.         if (serflg) irchost = cshostname;
  474.         else irchost = tcphostname;
  475.         while ((*irchost != '\0') && (*irchost != ':')) irchost++;
  476.         ircsize = 0;
  477.         if (*irchost == ':') {
  478.             irchost++;
  479.             while ((irchost[ircsize] != '\0') &&
  480.                    (irchost[ircsize] != ':')) ircsize++;
  481.             }
  482.         if (ircsize > 0) {
  483.             for (i=0; i < ircsize; i++) {
  484.                 prochost[i+5] = tolower(irchost[i]);
  485.                 }
  486.             prochost[ircsize+5] = 0;
  487.             }
  488.         else prochost[4] = 0;
  489.         i = strlen(prochost);
  490.         if (serflg) {
  491.             prochost[i] = 0x0d;
  492.             }
  493.         else {
  494.             prochost[i++] = 0x0d;
  495.             prochost[i] = 0x0a;
  496.             }
  497.         }
  498.     if (serflg) {
  499.         i = 0;
  500.         while (prochost[i] != 0) {
  501.             mout(prochost[i++]);
  502.             }
  503.         respflag = 1;
  504.         return(1);
  505.         }
  506.     else {
  507.         tcpwrite(prochost, strlen(prochost));
  508.         return(0);
  509.         }
  510.     }
  511. return(0);
  512. }
  513.  
  514. srvscroll()
  515. {
  516. register short i, n;
  517. unsigned char * cptr;
  518. short * iptr;
  519.  
  520. /* update character and attribute buffers */
  521. n = maxcnt/scrhsize - 1;
  522. n -= 2;
  523. cptr = chrbuff;
  524. iptr = atrbuff;
  525. for (i=0; i < n; i++) {
  526.     movmem(cptr+scrhsize, cptr, scrhsize);
  527.     movmem(iptr+scrhsize, iptr, scrhsize<<1);
  528.     cptr += scrhsize;
  529.     iptr += scrhsize;
  530.     }
  531. setmem(cptr, scrhsize, 0);
  532. setmem(iptr, scrhsize<<1, 0);
  533. }
  534.  
  535. srvswitch()
  536. {
  537. servermode ^= 1;
  538. if (servermode) {
  539.     curadr = maxcnt - scrhsize*2;
  540.     msgoffset = 0;
  541.     linelen = 0;
  542.     linetext = readbuff;
  543.     lineattr = (unsigned short *)(linetext + 512);
  544.     proctext = linetext + 1536;
  545.     procattr = (unsigned short *)(linetext + 2048);
  546.     prochost = linetext + 3072;
  547.     respflag = 0;
  548.     }
  549. else {
  550.     curadr = 0;
  551.     }
  552. setmem(chrbuff, maxcnt, 0);
  553. setmem(atrbuff, maxcnt<<1, 0);
  554. /* prevent drawing of saved input */
  555. in_len = 0;
  556. inrect.top = inrect.left = 32767;
  557. inrect.bottom = inrect.right = -32767;
  558.  
  559. /* update bitmap or screen */
  560. invldscr();
  561. newcur();
  562. }
  563.